﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using UnisysMassiveImporter_v2.Entidades.Mensajes;

namespace UnisysMassiveImporter_v2.Entidades.Configuracion
{
    [Serializable]
    [XmlRootAttribute(ElementName = "Thread_Config", IsNullable = false)]
    public class Thread_Config
    {

        [XmlElementAttribute("IIFDomain")]
        public string IIFDomain { get; set; }

        [XmlElementAttribute("IIFUser")]
        public string IIFUser { get; set; }

        [XmlElementAttribute("IIFPassword")]
        public string IIFPassword { get; set; }

        [XmlElementAttribute("InputQueue")]
        public string InputQueue { get; set; }

        [XmlElementAttribute("Delay")]
        public int Delay { get; set; }

        [XmlElementAttribute("Name")]
        public string Name { get; set; }

        [XmlElementAttribute("DirectoryOrganization")]
        public int DirectoryOrganization { get; set; }

        [XmlElementAttribute("DataPath")]
        public string DataPath { get; set; }

        [XmlElementAttribute("RequiredFields")]
        public string required_fields { get; set; }

        [XmlElementAttribute("ImagesPath")]
        public string ImagesPath { get; set; }

        [XmlElementAttribute("FileType")]//1: xml, 2: csv, 3: plano
        public int Filetype { get; set; }

        [XmlElementAttribute("MaxFiles")]//1: xml, 2: csv, 3: plano
        public int MaxFiles { get; set; }

      


        /// <summary>
        /// 
        /// </summary>
        /// <param name="ruta">Ruta física donde se almacenarán los archivos de configuracion correspondientes</param>
        /// <param name="objeto"></param>
        public void Salvar(string ruta, Thread_Config objeto)
        {
            try
            {
                //----------------------------------------------------------------------
                // Primero creamos el serializador que va a generar el XML a partir de
                // la clase que le hemos pasado. Después creamos el stream de salida
                // de nuestro programa, que escribirá el fichero.
                //----------------------------------------------------------------------
                XmlSerializer serializer = new XmlSerializer(typeof(Thread_Config));
                XmlTextWriter stream = new XmlTextWriter(ruta +"\\" +Name + ".xml", Encoding.UTF8);

                //----------------------------------------------------------------------
                // A fin de permitir una mejor claridad si lo abrimos desde el bloc de
                // notas, le indicaremos al stream, que emplee un estilo de formato
                // identado con tabulaciones.
                //----------------------------------------------------------------------
                stream.Formatting = Formatting.Indented;
                stream.Indentation = 1;
                //stream.IndentChar = '';

                //----------------------------------------------------------------------
                // Finalmente mandamos que cree el XML y se cierre el stream.
                //----------------------------------------------------------------------
                serializer.Serialize(stream, objeto);
                stream.Close();
            }
            catch (Exception exc)
            {
                Console.WriteLine(exc.Message);
            }
        }

        public static Thread_Config Cargar(string ruta,ref Configuration config)
        {
            try
            {
                InfoMessage message = new InfoMessage();
                message.sendMessage("Leyendo Configuracion del thread: " + ruta, InfoMessage.Information_Message, 558, "System",ref config);

                //----------------------------------------------------------------------
                // Primero creamos el serializador que va a interpretar el XML, para
                // poder crear una clase a partir de este fichero. Después creamos el
                // stream de entrada a nuestro programa, que leerá el fichero.
                //----------------------------------------------------------------------
                XmlSerializer serializer = new XmlSerializer(typeof(Thread_Config));
                XmlTextReader stream = new XmlTextReader(ruta);

                //----------------------------------------------------------------------
                // Creado el serializador y el stream, mandamos transformar el
                // contenido que vamos leyendo del stream, a un objeto del programa.
                //----------------------------------------------------------------------
                Thread_Config aux = (Thread_Config)serializer.Deserialize(stream);

                //----------------------------------------------------------------------
                // Cerramos el stream y devolvemos el objeto que hemos obtenido.
                //----------------------------------------------------------------------
                stream.Close();
                message.sendMessage("Configuracion cargada correctamente con los siguientes parametros:\n Nombre: ["
                    + aux.Name + "] \n IIFDomain: [" + aux.IIFDomain + "] \n IIFUser: [" + aux.IIFUser + "] \n InputQueue: [" +
                aux.InputQueue + "] \n DirectoryOrganization: [" + aux.DirectoryOrganization + "] \n DataPath: [" + aux.DataPath +
                "\n ImagesPath: [" + aux.ImagesPath + "] \n FileType: [" + aux.Filetype + "] \n Delay: [" + aux.Delay + "]\n MaxFiles: [" +
                aux.MaxFiles + "] \n" + "RequiredFields: ["+aux.required_fields +"]",
                    InfoMessage.Information_Message, 559, aux.Name,ref config);
                return aux;
            }
            catch (Exception e) { throw new Exception(e.Message); }
        }


        public static Thread_Config Load(string ruta)
        {
            try
            {
               
                //----------------------------------------------------------------------
                // Primero creamos el serializador que va a interpretar el XML, para
                // poder crear una clase a partir de este fichero. Después creamos el
                // stream de entrada a nuestro programa, que leerá el fichero.
                //----------------------------------------------------------------------
                XmlSerializer serializer = new XmlSerializer(typeof(Thread_Config));
                XmlTextReader stream = new XmlTextReader(ruta);

                //----------------------------------------------------------------------
                // Creado el serializador y el stream, mandamos transformar el
                // contenido que vamos leyendo del stream, a un objeto del programa.
                //----------------------------------------------------------------------
                Thread_Config aux = (Thread_Config)serializer.Deserialize(stream);

                //----------------------------------------------------------------------
                // Cerramos el stream y devolvemos el objeto que hemos obtenido.
                //----------------------------------------------------------------------
                stream.Close();
               
                return aux;
            }
            catch (Exception e) { throw new Exception(e.Message); }
        }

    }
}
